// store/userStore.js - 用户状态管理

// Token 和用户信息存储的 key
const TOKEN_KEY = "user_token";
const USER_INFO_KEY = "user_info";

class UserStore {
  constructor() {
    this.userInfo = null;
    this.token = null;
    this.isLogin = false;
    this.listeners = []; // 状态变化监听器
  }

  /**
   * 获取token
   * @returns {string|null} token
   */
  getToken() {
    return wx.getStorageSync(TOKEN_KEY) || null;
  }

  /**
   * 设置token
   * @param {string} token token值
   */
  setToken(token) {
    if (token) {
      wx.setStorageSync(TOKEN_KEY, token);
    } else {
      wx.removeStorageSync(TOKEN_KEY);
    }
  }

  /**
   * 清除token
   */
  clearToken() {
    wx.removeStorageSync(TOKEN_KEY);
  }

  /**
   * 初始化用户状态
   */
  init() {
    this.token = this.getToken();
    this.userInfo = wx.getStorageSync(USER_INFO_KEY) || null;
    this.isLogin = !!this.token;
    this.notifyListeners();
  }

  /**
   * 设置用户信息
   * @param {Object} userInfo 用户信息
   * @param {string} token 用户token
   */
  setUserInfo(userInfo, token) {
    this.userInfo = userInfo;
    this.token = token;
    this.isLogin = true;

    // 保存到本地存储
    if (token) {
      this.setToken(token);
    }
    if (userInfo) {
      wx.setStorageSync(USER_INFO_KEY, userInfo);
    }

    this.notifyListeners();
  }

  /**
   * 清除用户信息
   */
  clearUserInfo() {
    this.userInfo = null;
    this.token = null;
    this.isLogin = false;

    // 清除本地存储
    this.clearToken();
    wx.removeStorageSync(USER_INFO_KEY);

    this.notifyListeners();
  }

  /**
   * 获取用户信息
   * @returns {Object|null} 用户信息
   */
  getUserInfo() {
    return this.userInfo;
  }

  /**
   * 获取token
   * @returns {string|null} token
   */
  getToken() {
    return this.token;
  }

  /**
   * 检查是否已登录
   * @returns {boolean} 是否已登录
   */
  isLoggedIn() {
    return this.isLogin;
  }

  /**
   * 添加状态变化监听器
   * @param {Function} listener 监听器函数
   */
  addListener(listener) {
    this.listeners.push(listener);
  }

  /**
   * 移除状态变化监听器
   * @param {Function} listener 监听器函数
   */
  removeListener(listener) {
    const index = this.listeners.indexOf(listener);
    if (index > -1) {
      this.listeners.splice(index, 1);
    }
  }

  /**
   * 通知所有监听器
   */
  notifyListeners() {
    this.listeners.forEach((listener) => {
      if (typeof listener === "function") {
        listener({
          userInfo: this.userInfo,
          token: this.token,
          isLogin: this.isLogin,
        });
      }
    });
  }

  /**
   * 微信授权登录
   * @returns {Promise} 登录结果
   */
  async wxLogin() {
    return new Promise((resolve, reject) => {
      wx.login({
        success: async (res) => {
          if (res.code) {
            try {
              console.log("获取到微信code:", res.code);
              console.log("resresresresres", res);
              // 调用后端登录接口
              const { wxLogin } = require("../api/auth.js");
              console.log("准备调用wxLogin API，code:", res.code);
              const loginRes = await wxLogin(res.code);

              console.log("登录接口响应:", loginRes);

              // 明确的登录成功判断
              const hasResponse = !!loginRes;
              const hasData = !!loginRes?.data;
              const hasToken = !!loginRes?.data?.token;
              const tokenValue = loginRes?.data?.token;
              const codeValue = loginRes?.code;

              // console.log("=== 详细数据结构分析 ===");
              // console.log("完整响应:", JSON.stringify(loginRes, null, 2));
              // console.log("data字段:", loginRes?.data);
              // console.log("data.token:", loginRes?.data?.token);
              // console.log("data.userInfo:", loginRes?.data?.userInfo);
              // console.log("=========================");

              // 登录成功的条件：有响应 && code为0 && 有data
              // 注意：token可能在不同的位置，需要灵活判断
              const isLoginSuccess =
                hasResponse &&
                (codeValue === 0 || codeValue === "0") &&
                hasData;

              // console.log("=== 登录成功判断详情 ===");
              // console.log("1. 有响应:", hasResponse);
              // console.log("2. code值:", codeValue);
              // console.log("3. code === 0:", codeValue === 0);
              // console.log("4. code === '0':", codeValue === "0");
              // console.log("5. 有data:", hasData);
              // console.log("6. 有token:", hasToken);
              // console.log("7. token值:", tokenValue);
              // console.log("8. 最终判断:", isLoginSuccess);
              // console.log("9. message:", loginRes?.message);
              // console.log("=========================");

              if (isLoginSuccess) {
                // 提取用户信息和token
                const rawUserInfo = loginRes.data.userInfo || {};
                const token = loginRes.data.token;

                // console.log("原始用户信息:", rawUserInfo);
                // console.log("提取的token:", token);

                // 处理用户信息，提取重要字段
                const processedUserInfo = this.processUserInfo(rawUserInfo);

                console.log("处理后的用户信息:", processedUserInfo);

                this.setUserInfo(processedUserInfo, token);
                console.log("登录成功，保存用户信息:", {
                  userInfo: processedUserInfo,
                  token,
                });
                resolve({
                  userInfo: processedUserInfo,
                  token,
                  ...loginRes.data,
                });
              } else {
                console.error("=== 登录失败详情 ===");
                console.error("响应数据:", loginRes);
                console.error("失败原因:");
                console.error("- 有响应:", hasResponse);
                console.error("- 有data:", hasData);
                console.error("- 有token:", hasToken);
                console.error("===================");

                const errorMsg = `登录失败: ${
                  loginRes?.message || "未获取到token"
                }\n失败原因: 响应=${hasResponse}, data=${hasData}, token=${hasToken}`;
                reject(new Error(errorMsg));
              }
            } catch (error) {
              console.error("登录接口调用失败:", error);
              console.error("错误类型:", typeof error);
              console.error("错误消息:", error.message);
              console.error("错误堆栈:", error.stack);
              reject(error);
            }
          } else {
            reject(new Error("获取微信code失败"));
          }
        },
        fail: (err) => {
          reject(err);
        },
      });
    });
  }

  /**
   * 退出登录
   */
  logout() {
    this.clearUserInfo();

    // 可以在这里调用退出登录的API
    // 例如：await post('/api/user/logout');

    wx.showToast({
      title: "已退出登录",
      icon: "success",
    });
  }

  /**
   * 更新用户信息
   * @param {Object} newUserInfo 新的用户信息
   */
  updateUserInfo(newUserInfo) {
    this.userInfo = { ...this.userInfo, ...newUserInfo };
    wx.setStorageSync(USER_INFO_KEY, this.userInfo);
    this.notifyListeners();
  }

  /**
   * 处理用户信息，提取重要字段
   * @param {Object} rawUserInfo 原始用户信息
   * @returns {Object} 处理后的用户信息
   */
  processUserInfo(rawUserInfo) {
    return {
      // 基本信息
      id: rawUserInfo.id || "",
      nickname: rawUserInfo.nickname || "微信用户",
      phone: rawUserInfo.phone || "",
      openid: rawUserInfo.openid || "",
      unionid: rawUserInfo.unionid || "",
      avatarUrl: rawUserInfo.avatarUrl || "",
      isLeader: rawUserInfo.isLeader || 0,

      // 会话信息
      sessionKey: rawUserInfo.sessionKey || "",
      sessionId: rawUserInfo.sessionId || "",
      loginType: rawUserInfo.loginType || "JSCODE",

      // 时间信息
      expiredTime: rawUserInfo.expiredTime || "",

      // 权限信息
      authorities: rawUserInfo.authorities || null,

      // 注册信息
      regFromId: rawUserInfo.regFromId || "-1",

      // 保留原始数据
      ...rawUserInfo,
    };
  }

  /**
   * 获取用户ID
   * @returns {string} 用户ID
   */
  getUserId() {
    return this.userInfo?.id || "";
  }

  /**
   * 获取用户昵称
   * @returns {string} 用户昵称
   */
  getUserNickname() {
    return this.userInfo?.nickname || "微信用户";
  }

  /**
   * 获取用户手机号
   * @returns {string} 用户手机号
   */
  getUserPhone() {
    return this.userInfo?.phone || "";
  }

  /**
   * 获取用户OpenID
   * @returns {string} 用户OpenID
   */
  getUserOpenId() {
    return this.userInfo?.openid || "";
  }

  /**
   * 获取用户UnionID
   * @returns {string} 用户UnionID
   */
  getUserUnionId() {
    return this.userInfo?.unionid || "";
  }

  /**
   * 获取用户头像URL
   * @returns {string} 用户头像URL
   */
  getUserAvatarUrl() {
    return this.userInfo?.avatarUrl || "";
  }

  /**
   * 获取用户团长状态
   * @returns {number} 1表示团长，0表示普通用户
   */
  getIsLeader() {
    return this.userInfo?.isLeader || 0;
  }

  /**
   * 检查用户是否为团长
   * @returns {boolean} 是否为团长
   */
  isUserLeader() {
    return this.getIsLeader() === 1;
  }

  /**
   * 获取会话ID
   * @returns {string} 会话ID
   */
  getSessionId() {
    return this.userInfo?.sessionId || "";
  }

  /**
   * 获取过期时间
   * @returns {string} 过期时间戳
   */
  getExpiredTime() {
    return this.userInfo?.expiredTime || "";
  }

  /**
   * 检查token是否有效
   * @returns {boolean} token是否有效
   */
  isTokenValid() {
    if (!this.token) {
      return false;
    }

    // 检查过期时间
    const expiredTime = this.getExpiredTime();
    if (expiredTime) {
      const currentTime = Date.now();
      const expiredTimestamp = parseInt(expiredTime);
      if (currentTime >= expiredTimestamp) {
        console.log("Token已过期");
        return false;
      }
    }

    return true;
  }
}

// 创建单例实例
const userStore = new UserStore();

// 初始化
userStore.init();

module.exports = userStore;
